﻿/*-----------------------------------------------------------------------
 * <copyright file="Common.cs" company="O-RID">
 *     Copyright (c)2010 O-RID Co.,Ltd.
 * </copyright>
 * <author>Zhang Jun</author>
 * <summary>
 *          公有方法的定义
 *          作成日：05/21/2010
 *                  06/02/2010 --ADD-- 格式化千位分割符 
 *                  06/22/2010 --ADD-- 转换大写字符串
 *                  06/23/2010 --edit-- 字符串格式 Accuracy为 ***.**%
 *                  07/13/2010 --ADD-- 非数据字段的格式化/除法计算
 *                  11/08/2010 --edit-- 将MyToFormat的参数修改为枚举型
 * </summary>
 *-----------------------------------------------------------------------
 */

namespace Orid.Management.Statistics.Service.OPUnitService 
{
    using System;
    using System.Data.SqlClient;
    using System.Runtime.Serialization;

    /// <summary>
    /// Common
    /// 公用方法类
    /// </summary>
    public class Common
    {
        private Common() { }

        #region 自定义MyIsNullOrEmpty
        /// <summary>
        /// 如果判断字符串为空值，返回指定的值
        /// </summary>
        /// <param name="inputStr">inputStr 判断是否为空值</param>
        /// <param name="retStr">当inputStr为空值时的返回值</param>
        /// <returns>空字符串 或 retStr值</returns>
        public static string MyIsNullOrEmpty(string inputStr, string retStr)
        {
            return !String.IsNullOrEmpty(inputStr) ? inputStr : retStr;
        }

        #endregion 自定义MyIsNullOrEmpty

        #region myIsDBNull
        /// <summary>
        /// 判断数据库返回值是否为NULL。如果为NULL,返回string.Empty
        /// </summary>
        /// <param name="read">read SqlDataReader</param>
        /// <param name="dbname">dbname 字段名</param>
        /// <returns>如果为NULL, 返回string.Empty</returns>
        public static string MyIsDBNull(SqlDataReader read, string dbname) 
        {
            return read[dbname] != DBNull.Value ? read[dbname].ToString().Trim() : string.Empty;
        }

        //06/22/2010 --ADD--转换大写字符串
        /// <summary>
        /// 重载myIsDBNull
        /// 判断数据库返回值是否为NULL。如果为NULL,返回string.Empty
        /// 不为空时，按条件判断是否返回大字字符串
        /// </summary>
        /// <param name="read">read SqlDataReader</param>
        /// <param name="dbname">dbname 字段名</param>
        /// <param name="isUpper">True：大写字符串，False:小写字符串</param>
        /// <returns>string.Empty值、True：大写字符串、False:字符串原型</returns>
        public static string MyIsDBNull(SqlDataReader read, string dbname, bool isUpper)
        {
            if (isUpper == true) 
            {
                return read[dbname] != DBNull.Value ? read[dbname].ToString().Trim().ToUpper() : string.Empty;
            }
            else
            {
                return read[dbname] != DBNull.Value ? read[dbname].ToString().Trim(): string.Empty;
            }
        }

        #endregion myIsDBNull

        #region MyToFormat 对 字段格式化
        /// <summary>
        /// 对 字段格式化
        /// 格式化千位分割符（DOUBLE类型）
        /// 格式化日期（DATETIME类型）
        /// 字符串格式 ***.**% (DOUBLE类型,%)
        /// </summary>
        /// <param name="read">read SqlDataReader</param>
        /// <param name="dbname">SqlDataReader 字段名</param>
        /// <param name="varClass">varClass 想要转换的字段类型</param>
        /// <param name="format">format 要转换的格式 %: *100之后加百分号. 其它可自行决定</param>
        /// <returns>format 型式的字符串</returns>
        public static string MyToFormat(SqlDataReader read, string dbname, ClassType varClass, string format)
        {
            
            switch ((int)varClass)
            {
                //--06/02/2010--ADD 格式化千位分割符 或是 %（DOUBLE类型） 
                case (int)ClassType.DOUBLE :

                if (!string.IsNullOrEmpty(read[dbname] != DBNull.Value ? read[dbname].ToString().Trim() : string.Empty)) 
                {
                    //如果用 %，返回结果为 X*100 + % 
                    if (format.Equals("%") || format.Equals("％"))
                    {
                        //--06/23/2010--ADD字符串格式 ***.**% (DOUBLE类型,%)
                        return (Convert.ToDouble(read[dbname])*100).ToString("##0.00")+"%";
                    }
                    // 不用% ，按格式化返回
                    else 
                    {
                        return Convert.ToDouble(read[dbname]).ToString(format);
                    }
                }
                break;

                case (int)ClassType.DATETIME:

                if (!string.IsNullOrEmpty(read[dbname] != DBNull.Value ? read[dbname].ToString().Trim() : string.Empty))
                {
                    return Convert.ToDateTime(read[dbname]).ToString(format);
                }
                break;
            }

            return string.Empty;
        }

        /// <summary>
        /// 自定义 转换目标类型
        /// </summary>
        public enum ClassType
        {
            /// <summary>
            /// 转换目标类型为 double
            /// </summary>
            DOUBLE,

            /// <summary>
            /// 转换目标类型为 datetime
            /// </summary>
            DATETIME
        }
        #endregion MyToFormat 对 字段格式化

        #region MyToFormat 对 非数据库字段 进行格式化
        /// <summary>
        /// 对 非数据库字段 进行格式化
        /// </summary>
        /// <param name="dbname">变量</param>
        /// <param name="format">%：*100+% 百分化</param>
        /// <returns></returns>
        public static string MyToFormat(double dbname,string format)
        {
            if (dbname!=0)
            {
                if (format.Equals("%") || format.Equals("％"))
                {
                    //--06/23/2010--ADD字符串格式 ***.**% (DOUBLE类型,%)
                    return (Convert.ToDouble(dbname) * 100).ToString("##0.00") + "%";
                }
                else
                {
                    return "0.00%";
                }
            }
            return string.Empty;
        }

        #endregion MyToFormat 对 非数据库字段 进行格式化

        #region MyToCompute 除法计算
        /// <summary>
        /// 除法计算
        /// </summary>
        /// <param name="sqlDataRead">SqlDataReader</param>
        /// <param name="dividendName">被除数 </param>
        /// <param name="divisorName">除数</param>
        /// <returns></returns>
        public static double MyToCompute(SqlDataReader sqlDataRead, string dividendName, string divisorName) 
        {
            //判断被除数
            if ((sqlDataRead[dividendName].Equals(DBNull.Value))) 
            {
                return 0.00;
            }
            //判断除数
            if ((sqlDataRead[divisorName].Equals(DBNull.Value)))
            {
                return 0.00;
            }

            return Convert.ToDouble(sqlDataRead[dividendName]) / Convert.ToDouble(sqlDataRead[divisorName]);
        }

        #endregion MyToCompute 除法计算
    }
}
